home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Software Vault: The Gold Collection
/
Software Vault - The Gold Collection (American Databankers) (1993).ISO
/
cdr49
/
mtl100je.zip
/
BUFFERS.H
< prev
next >
Wrap
C/C++ Source or Header
|
1993-05-06
|
5KB
|
139 lines
//--------------------------------------------------------------------------
//
// BUFFERS.H: header file for DOSMonitor-based bounded buffer.
// Copyright (c) J.English 1993.
// Author's address: je@unix.brighton.ac.uk
//
// Permission is granted to use copy and distribute the
// information contained in this file provided that this
// copyright notice is retained intact and that any software
// or other document incorporating this file or parts thereof
// makes the source code for the library of which this file
// is a part freely available.
//
//--------------------------------------------------------------------------
//
// Revision history:
// 1.0 March 1993 Initial coding
//
//--------------------------------------------------------------------------
#ifndef __BUFFERS_H
#define __BUFFERS_H
#include "threads.h"
//--------------------------------------------------------------------------
//
// Class BoundedBuffer.
//
// This is a template for a DOSMonitor-based bounded buffer.
// The constructor requires the size of the buffer as a parameter.
// The member functions "get" and "put" allow individual data items
// to be taken out of and put into the buffer. The member function
// "close" allows the buffer to be closed against further use. The
// member function "items" returns the number of items currently in
// the buffer.
//
template<class T> class BoundedBuffer : public DOSMonitor
{
public:
BoundedBuffer (unsigned n) : buffer(new T[n]), buffersize(n),
count(0), inptr(0), outptr(0), closed(0)
{ }
~BoundedBuffer () { delete [] buffer; }
unsigned items () { return count; }
int get (T& item); // get an item from the buffer
int put (const T& item); // put an item into the buffer
void close (); // close buffer against further use
private:
DOSMonitorQueue full;
DOSMonitorQueue empty;
T* buffer;
unsigned buffersize;
unsigned count;
unsigned inptr;
unsigned outptr;
unsigned closed;
};
//--------------------------------------------------------------------------
//
// BoundedBuffer::get.
//
// Get an item from the buffer. The thread will be suspended on the
// "empty" queue as long as the buffer is empty or until the buffer
// is closed. If the buffer is closed, the function will return 0.
// Otherwise, the next item is extracted and the "inptr" is moved
// to point to the next item. Finally, any threads waiting while the
// buffer is full are resumed (since there is now an empty space in
// the buffer) and the value 1 is returned to indicate success.
//
template <class T> int BoundedBuffer<T>::get (T& item)
{
lock ();
while (count == 0 && !closed)
suspend (empty); // await non-empty buffer
if (count != 0)
{ item = buffer [inptr++];
inptr %= buffersize;
count--;
resume (full); // awaken threads waiting for non-full buffer
}
unlock ();
return !closed;
}
//--------------------------------------------------------------------------
//
// BoundedBuffer::put.
//
// Put an item into the buffer. The thread will be suspended on the
// "full" queue as long as the buffer is empty or until the buffer
// is closed. If the buffer is closed, the function will return 0.
// Otherwise, the item is stored in the next available space and
// "outptr" is moved to point to the next free space. Finally,
// any threads waiting while the buffer was empty are resumed (since
// there is now an item in the buffer) and the value 1 is returned
// to indicate success.
//
template <class T> int BoundedBuffer<T>::put (const T& item)
{
lock ();
while (count == buffersize && !closed)
suspend (full); // await non-full buffer
if (count != buffersize)
{ buffer [outptr++] = item;
outptr %= buffersize;
count++;
resume (empty); // awaken threads waiting for non-empty buffer
}
unlock ();
return !closed;
}
//--------------------------------------------------------------------------
//
// BoundedBuffer::close.
//
// This function closes the buffer against further use. The "closed"
// flag is set and any suspended threads are resumed. This is to guard
// against situations where a thread might wait forever for an item
// which never arrives, which would prevent the program from ever
// terminating.
//
template <class T> void BoundedBuffer<T>::close ()
{
lock ();
closed = 1;
resume (full);
resume (empty);
unlock ();
}
#endif